EnigmA Amiga Run 1996 March/EnigmA AMIGA RUN 05 (1996)(G.R. Edizioni)(IT)[!][issue 1996-03][Skylink CD IV].iso/earcd/comm2/ipdilv19.lha/IPDial_v1.9/DeviceIO.c

C/C++ Source or Header | 1995-11-13 | 5KB | 205 lines

/**
***  IPDial     Script program for initializing a SLIP connection
***  Copyright  (C)   1994    Jochen Wiedmann
***
***  This program is free software; you can redistribute it and/or modify
***  it under the terms of the GNU General Public License as published by
***  the Free Software Foundation; either version 2 of the License, or
***  (at your option) any later version.
***
***  This program is distributed in the hope that it will be useful,
***  but WITHOUT ANY WARRANTY; without even the implied warranty of
***  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
***  GNU General Public License for more details.
***
***  You should have received a copy of the GNU General Public License
***  along with this program; if not, write to the Free Software
***  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
***
***
***
***  This file implements something like a device class. It's only
***  reason is the lack of a possibility to determine the real state
***  of an IORequest. (Sent? Inactive? Whatever else?)
***
***
***  Computer: Amiga 1200                       Compiler: Dice 3.01
***
***  Author:    Jochen Wiedmann
***             Am Eisteich 9
***             72555 Metzingen
***             Germany
***
***             Phone: [phone] / 14881
***             Internet: [e-mail]
**/

/**
***  Include files
**/
#ifndef IPDIAL_H
#include "IPDial.h"
#endif
#include <exec/devices.h>
#include <exec/io.h>
/**
***  We use the structure below for device IO, because I don't see
***  any way to check an IORequest whether it must be aborted, before
***  using or deleting it.
**/
struct MyIORequest
{
  ULONG Used;
  ULONG Signal;
  ULONG DeviceOpen;
  struct IORequest *Req;
};
/**
***  This is the WaitIO() equivalent.
**/
BYTE DeviceIOWait(APTR wreq)
{
  struct MyIORequest *req = wreq;
  BYTE result;

  result = WaitIO(req->Req);
  req->Used = FALSE;
  return(result);
}
/**
***  This is the AbortIO() equivalent.
**/
VOID DeviceIOAbort(APTR areq)
{ struct MyIORequest *req = areq;

  if (req  &&  req->Used  &&  req->Req)
  {
    AbortIO(req->Req);
    DeviceIOWait(req);
  }
  /**
  ***  The following is needed for reasons I don't understand
  ***  really.
  **/
  SetSignal(0, req->Signal);
}
/**
***  This is the SendIO() equivalent.
**/
VOID DeviceIOSend(APTR sreq, UWORD Command)
{
  struct MyIORequest *req = sreq;

  if (req->Used)
  {
    fprintf(stderr, "Internal error: IORequest in use.\n");
    exit(20);
  }
  req->Used = TRUE;
  req->Req->io_Command = Command;
  SendIO(req->Req);
}
/**
***  This is the DoIO() equivalent.
**/
BYTE DeviceIODo(APTR dreq, UWORD Command)
{
  BYTE   status;
  struct MyIORequest *req = dreq;

  if (req->Used)
  {
    fprintf(stderr, "Internal error: IORequest in use.\n");
    exit(20);
  }
  req->Req->io_Command = Command;
  status = DoIO(req->Req);
  Delay(10);
  return(status);
}
/**
***  This is the DeleteIORequest() equivalent.
**/
VOID DeviceIODelete(APTR dreq)
{
  struct MyIORequest *req = dreq;

  if (req)
  {
    DeviceIOAbort(req);
    if (req->DeviceOpen)
    {
      CloseDevice(req->Req);
    }
    if (req->Req)
    {
      struct MsgPort *port = req->Req->io_Message.mn_ReplyPort;

      DeleteIORequest(req->Req);
      DeleteMsgPort(port);
    }
    free(req);
  }
}
/**
***  This is the CreateIORequest() equivalent.
**/
APTR DeviceIOCreate(ULONG Size)
{
  struct MyIORequest *req;

  if ((req = malloc(sizeof(*req))))
  {
    struct MsgPort *port;

    req->Used = FALSE;
    req->DeviceOpen = FALSE;
    if ((port = CreateMsgPort()))
    {
      req->Signal = (1 << port->mp_SigBit);
      if ((req->Req = CreateIORequest(port, Size)))
      {
        return(req);
      }
      DeleteMsgPort(port);
    }
    free(req);
  }
  return(NULL);
}
/**
***  This is the OpenDevice() equivalent.
**/
BYTE DeviceIOOpen(STRPTR devname, ULONG unit, APTR oreq, ULONG flags)
{
  struct MyIORequest *req = oreq;
  BYTE error;

  if (req->DeviceOpen)
  {
    fprintf(stderr, "Internal error: Device already open.\n");
    exit(20);
  }
  if (!(error = OpenDevice(devname, unit, req->Req, flags)))
  {
    req->DeviceOpen = TRUE;
  }
  return(error);
}
/**
***  This function returns the IORequest attached to a struct
***  MyIORequest.
**/
struct IORequest *DeviceIOReq(APTR rreq)
{
  return(((struct MyIORequest *)rreq)->Req);
}
/**
***  This function returns an IORequest's signal. (Not the
***  signal number.)
**/
ULONG DeviceIOSignal(APTR sreq)
{
  return(((struct MyIORequest *) sreq)->Signal);
}